
#include "Nodo.h"
#include "othello_cut.h"

Nodo::Nodo(bool empiezaBlanco) {
    this->JuegaBlanco = empiezaBlanco;
    estado = state_t(6);

    this->negros = (unsigned char*) malloc(sizeof (unsigned char) * 4);
    this->TamNegros = 4;

    this->blancos = (unsigned char*) malloc(sizeof (unsigned char) * 4);
    this->TamBlancos = 4;

}

Nodo::Nodo(int pos, Nodo *d) {
    unsigned char candNegro[36];
    unsigned char candBlanco[36];
    unsigned char posV[] = {-6, -1, 1, 6};

    int n = 0, b = 0, k;

    JuegaBlanco = !d->JuegaBlanco;

    for (k = 0; k < 4; k++) {
        int pActual = pos + posV[k];

        if (d.estado->is_free(pActual)) {
            if (adyacentesNegros(pActual) && !Existe(pActual, d->negros, d->TamNegros))
                candNegro[n++] = pActual;

            if (adyacentesBlancos(pActual) && !Existe(pActual, d->blancos, d->TamBlancos))
                candBlanco[b++] = pActual;
        }
    }

    TamBlancos = d->TamBlancos + b - 1;
    TamNegros = d->TamNegros + n - 1;

    negros = (unsigned char*) malloc(sizeof (unsigned char) * TamNegros);
    blancos = (unsigned char*) malloc(sizeof (unsigned char) * TamBlancos);

    int enc = 0;
    for (k = 0; k < d->TamBlancos; k++) {
        int pActual = d->blancos[k];
        if (enc = (pActual != pos))
            blancos[k - enc] = pActual;
    }

    int l = d->TamBlancos - 1;
    for (k = 0; k < b; k++) {
        blancos[k + l] = candBlanco[k];
    }


    enc = 0;
    for (k = 0; k < d->TamNegros; k++) {
        int pActual = d->negros[k];
        if (enc = (pActual != pos))
            negros[k - enc] = pActual;
    }


    l = d->TamNegros - 1;
    for (k = 0; k < n; k++) {
        negros[k + l] = candNegro[k];
    }


}

bool Nodo::Existe(unsigned char val, unsigned char *arr, int tam) {
    for (--tam; tam >= 0 && arr[tam] != val; tam--);
    return tam >= 0;
}

bool Nodo::adyacentesBlancos(int pos) {

    return estado.is_white(pos + 1) || estado.is_white(pos - 1) || estado.is_white(pos + 6) || estado.is_white(pos - 6);
}

bool Nodo::adyacentesNegros(int pos) {

    return estado.is_black(pos + 1) || estado.is_black(pos - 1) || estado.is_black(pos + 6) || estado.is_black(pos - 6);
}

bool Nodo::esTerminal() const {

    return estado.terminal();
}

int Nodo::Valor() const {

    return estado.value();
}

Nodo::~Nodo() {

}

Nodo::Iterador::Iterador(Nodo *nodo, bool ordenamientoMax) {

}

Nodo *Nodo::Iterador::Siguiente() {

}

Nodo::Iterador::~Iterador() {

}




